node:test: cancel the running file of run() when its signal aborts - #47360

Reproduction. One file installs a SIGTERM listener that lets its one test pass. The caller aborts when the file prints ready.

// trap.js
const { test } = require("node:test");
let end;
const ended = new Promise(resolve => (end = resolve));
process.on("SIGTERM", end);
console.log("ready");
test("runs until SIGTERM", { timeout: 60_000 }, async () => {
  const limit = setTimeout(end, 60_000);
  await ended;
  clearTimeout(limit);
});

const controller = new AbortController();
const stream = run({ files: ["trap.js"], signal: controller.signal });
stream.on("test:stdout", ({ message }) => message.includes("ready") && controller.abort());

Reach.

• A fuzz run found this. No user reported it, and there is no issue. The first record is a review comment on node:test: run(), expectFailure, and Node v26.3.0 skip/todo semantics #34444: node:test: run(), expectFailure, and Node v26.3.0 skip/todo semantics #34444 (comment)
• The verdict of the run changes only when the child of the aborted file does not die from SIGTERM: it handles the signal and exits with code 0 (main reports success: true), or it runs on (main does not end the stream until it exits).
• When SIGTERM ends the child, main already ends with success: false. There this PR changes the labels: the file was failed with testCodeFailure, and it is cancelled with testAborted and the reason of the abort. A caller that reads only counts.failed sees 0 after an abort now, as in Node.js.
• This is the run() part of Node's Test#abortHandler. The signal option of a test and of a suite is other code (node:test: abort t.signal and enforce the test-level signal option #39287, node:test: enforce the timeout and signal options of suites #39312).

What Node.js does (v26.3.0, lib/internal/test_runner).

• Test#abortHandler (test.js L1058-L1062) takes signal.reason, or a new AbortError('The test was aborted') when the reason is falsy, sets failureType = 'testAborted' on it and cancels the test (L1064-L1077).
• A test whose signal is aborted when it starts does not run its function (L1306-L1309). For a file, that function is the spawn.
• The file test waits for the exit of the child and the end of its stdout, both with the signal (runner.js L557-L560). An abort after that point leaves the verdict of the file, in Node.js and here. The data listener stays on the pipe after the abort (L536-L538). A child error event fails the file (L532-L534).
• Node.js tests the option in test/parallel/test-runner-run.mjs ("should accept a signal"): two files that never end and AbortSignal.timeout(50) give two test:fail events and no test:pass. Bun does not vendor that file. The case is in the fixture of this PR, with the failure types: main gives testCodeFailure and cancelledByParent, Node.js and this PR give testAborted twice, with the reason itself.

Where this PR differs from Node.js on purpose. Each line is from a probe with Node.js v26.3.0.

• Signal aborted before run(), three files. Node.js publishes test:fail for the first file, test:plan 1 and a summary that counts 3 tests and 3 cancelled. It reports the other two files after the summary, and only to listeners: the readable side of the stream never has them. This PR publishes a test:fail for each file before the plan, and test:plan 3.
• A reason that cannot take a property. For abort("stop"), the abort listener of Node.js throws TypeError: Cannot create property 'failureType' on string 'stop'. The file fails with uncaughtException, and the process prints the TypeError and exits with code 1. A frozen error gives TypeError: Cannot add property failureType, object is not extensible the same way. This PR fails the file with an AbortError whose cause is the reason.

Listeners that throw.

• Node.js fails the running file with uncaughtException and goes on (harness.js L164-L165). Bun destroys the stream with the error of the listener, on main and here. This PR does not change that.
• A listener that aborts the signal and then throws, in one call: the stream fails with the error of the listener, as on main. The error is recorded when it is thrown (publishLine), because the reader that called the listener rejects only after it closed its pipe.
• The error of a test:stderr listener waits for the end of stdout, with and without a signal, as on main. Once stdout ended, it ends the run at once.
• One difference from main: after a test:stdout listener throws, the stream fails at once. Main first published the stderr lines of the child that it had not read yet, and then failed.

Smaller changes in the same function.

• The details of test:complete for a file that the signal cancelled, or whose child did not start, has no prototype, as each other details object of the stream and as in Node.js. On main, the details of a file that did not start inherited from Object.prototype. Its keys have the order of Node.js: duration_ms, type, error, passed. For a file that did not start, that is the order of main too. For a file that was running at the abort, it differs from main, which has passed before error.
• A child that cannot start: Bun.spawn throws, and the file fails with ERR_TEST_FAILURE / testCodeFailure and the spawn error as cause. The next file runs. On main the stream failed with the spawn error.

What stays different from Node.js, not changed here.

• An abort in a listener of the test:summary of a file. In Node.js the child still runs at that point, so the file is cancelled. Bun makes that summary after the child exited, so the run passes. The fixture records this as a todo test under Bun.
• A run that never aborts still waits for the stderr of the child to end before the verdict of the file. Node.js waits for the exit and for stdout only.
• A process of the child that holds the pipes keeps the runner process alive until it closes them, on main, in Node.js and here. With sleep 6 started by the test file, the stream ends 6,000 ms after the abort on main, 0 to 2 ms after it here, and 2 to 5 ms after it in Node.js. The process can exit about 6,000 ms after the abort in all three.

Overlap with open PRs. Each of these edits the same lines. By trial merge, #47286, #45717, #39284 and #46847 merge into main today and conflict with this PR. The others already conflict with main.

• node:test: --test CLI mode, node:test/reporters, standalone execution, and reporter-output parity (+18 tests, test_runner 32%→55%) #34515 rewrites the same lines of runFiles() with another model. A signal that aborts during the run counts one failure and publishes test:interrupted, with no test:fail for the running file or for the later files. In Node.js, test:interrupted comes from SIGINT and SIGTERM of the CLI runner (harness.js L315-L334), and an aborted signal option gives the testAborted failures of this PR. The two PRs need one decision from the owner of run(): what an aborted signal publishes.
• node:test: count a failed subtest by itself, and fold subtests as Node does #47286 makes runOneFile return a boolean. After it, the two early returns before the spawn return false, and the return of a cancelled file returns that boolean.
• node:test: do not call the public Promise methods in the runner #46959 and node:test: run a test's hooks before the next test when the bun:test timeout ends it #43803 each add a helper named untilStopped, with other signatures. The helper here is firstOf, so no two functions get one name.
• node:test: abort t.signal and enforce the test-level signal option #39287 and node:test: enforce the timeout and signal options of suites #39312 each add abortFailure(signal) after makeTestFailure, without the failureType. The one here is at the same place, so the second to land gets a conflict there and not a second function of that name.
• node:test: store a test failure as node's ERR_TEST_FAILURE, with the thrown value as its cause #45717 edits the cancelledByParent line that this PR removes, and one row of its tests expects that failure type for a cancelled file.
• node:test run(): report child events in byte frames that printed text cannot produce #45003 replaces the stdout loop that is readLines here, and the line format that the controlled-child fixture writes. node:test: republish run() child events at the child's nesting #39284 and node:test: report a verdict for each suite registered with bun:test under run() #39331 add an argument to runOneFile and reportCancelledFile. node:test: hand run({ argv }) to the test file in the child's environment #46847 and node:test: give each file of run() the runtime flags of its caller #45549 edit the arguments of the spawn.

Tests. All four are in test/js/node/test_runner/node-test.test.ts.

• fixtures/30-run-signal.js uses node:test and node:assert, with real children: 12 tests. One test runs it with bun test --concurrent and expects 11 pass and 1 todo (on Windows 8 pass, 3 skipped for POSIX signals, 1 todo). One test runs it with Node.js (12 pass), and is skipped when Node.js is older than v26.3.0.
• fixtures/run-controlled-child-fixture.ts replaces Bun.spawn in its own process. Each scenario holds the pipes, the exit and kill() of the child, so the abort or the error of a listener comes at one exact point: while the child runs, in the middle of a chunk, after stdout ended, after the exit while only stderr is open, after the file ended. It also pins what must not change for a run that never aborts: the test:stderr lines, the failure message of a file that exits with code 1, one kill() per child, no abort listener left on the signal, the keys of details.
• One test with a real child pins that nothing of the child follows an abort that a listener made, not even the rest of a line.
• With src/ of main: 3 of the 4 tests fail, on the debug build and on a release build. The fourth is the Node.js run.
• Mutation check: 45 small changes of the new code in the bundled module (no check before the spawn, no kill(), Bun.spawn gets the signal again, a reader that decodes or publishes after the abort, each wait without the abort, the wrong count, no cause, another key order, and so on). A test fails for each of the 45.
• Also ran on the debug build: all of node-test.test.ts (49 pass), the six vendored tests that call run() (test-runner-expect-error.js, test-runner-expect-error-but-pass.js, test-runner-filetest-location.js, test-runner-todo-skip-tests.js, test-runner-tags-validation.mjs, test-runner-tags-experimental-warning.mjs), bun lint, bun fmt --check, and tsc -p src/js/tsconfig.json (no error in node/test.ts).
• The 30 s on the fixture's tests and on the two tests that run it: without it, one run in four of the debug build timed out at the 5 s default on a busy machine, and the run that the test left behind failed the next tests.

Measurements. Release builds of the merge base (000ef50) and of this PR at 6ec9b6d, x64 Linux. The last commit moves one function and changes the order of two keys: its bundled module has the same size. Node.js is v26.3.0.

• Cells: the sum of heapStats().objectTypeCounts, JIT off. For the per-file count, Bun.spawn gives a child that reports one test and exits, and the count is the growth from 100 to 200 and from 200 to 300 files in one run. Three runs each agree within 1 cell.
• Instructions: user space, perf_event_open, JIT off, main and PR in turn, whole process. Ranges for the load: main 37,619,040 to 37,648,576, PR 37,751,185 to 37,798,907. The first file of a run with a signal loads internal/abort_listener.
• A run in which no listener throws and that never aborts publishes the same events as on main. Seven files (a pass, a failure, a throw at the top level, a suite with a skipped and a todo test, no test, an exit code 3, a missing file), with and without a signal, 30 runs each on main and on this PR: all 120 runs give the same 52 events and the same 55 test:stderr lines, apart from the line numbers of node:test frames in a stack trace.
• Abort to end of stream, for a child that exits 700 ms after SIGTERM with code 0, 20 runs each. main: 707 ms (705 to 740), success: true. This PR: 0.8 ms (0.6 to 1.8), success: false, the child still runs at the end. Node.js: 4.5 ms (1.7 to 6.8), success: false, the child still runs at the end.
• A child that ignores SIGTERM and exits after 2.5 s, 5 runs each, ms after the abort:

A plain script stays alive until the pipes of the child close, as in Node.js. bun test exits when its tests end, so there the child outlives the parent.

Self-review. The review of the first commit raised 15 concerns. The two that are not done: one wait path for runs with and without a signal (it costs 32 more cells per file for a run without a signal, and the difference it removes is gone), and a fixture that does not write the line format of the child itself (main exports no writer for it). An issue on the tracker does not exist yet. The two gaps under "What stays different" went to separate work.